/*
 * XML Type:  OFX
 * Namespace: http://ofx.net/types/2003/04
 * Java type: net.ofx.types.x2003.x04.OFX
 *
 * Automatically generated - do not modify.
 */
package net.ofx.types.x2003.x04.impl;
/**
 * An XML OFX(@http://ofx.net/types/2003/04).
 *
 * This is a complex type.
 */
public class OFXImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.ofx.types.x2003.x04.OFX
{
    
    public OFXImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName SIGNONMSGSRQV1$0 = 
        new javax.xml.namespace.QName("", "SIGNONMSGSRQV1");
    private static final javax.xml.namespace.QName SIGNUPMSGSRQV1$2 = 
        new javax.xml.namespace.QName("", "SIGNUPMSGSRQV1");
    private static final javax.xml.namespace.QName BANKMSGSRQV1$4 = 
        new javax.xml.namespace.QName("", "BANKMSGSRQV1");
    private static final javax.xml.namespace.QName CREDITCARDMSGSRQV1$6 = 
        new javax.xml.namespace.QName("", "CREDITCARDMSGSRQV1");
    private static final javax.xml.namespace.QName INVSTMTMSGSRQV1$8 = 
        new javax.xml.namespace.QName("", "INVSTMTMSGSRQV1");
    private static final javax.xml.namespace.QName INTERXFERMSGSRQV1$10 = 
        new javax.xml.namespace.QName("", "INTERXFERMSGSRQV1");
    private static final javax.xml.namespace.QName WIREXFERMSGSRQV1$12 = 
        new javax.xml.namespace.QName("", "WIREXFERMSGSRQV1");
    private static final javax.xml.namespace.QName BILLPAYMSGSRQV1$14 = 
        new javax.xml.namespace.QName("", "BILLPAYMSGSRQV1");
    private static final javax.xml.namespace.QName EMAILMSGSRQV1$16 = 
        new javax.xml.namespace.QName("", "EMAILMSGSRQV1");
    private static final javax.xml.namespace.QName SECLISTMSGSRQV1$18 = 
        new javax.xml.namespace.QName("", "SECLISTMSGSRQV1");
    private static final javax.xml.namespace.QName PRESDIRMSGSRQV1$20 = 
        new javax.xml.namespace.QName("", "PRESDIRMSGSRQV1");
    private static final javax.xml.namespace.QName PRESDLVMSGSRQV1$22 = 
        new javax.xml.namespace.QName("", "PRESDLVMSGSRQV1");
    private static final javax.xml.namespace.QName PROFMSGSRQV1$24 = 
        new javax.xml.namespace.QName("", "PROFMSGSRQV1");
    private static final javax.xml.namespace.QName TAX1098MSGSRQV1$26 = 
        new javax.xml.namespace.QName("", "TAX1098MSGSRQV1");
    private static final javax.xml.namespace.QName TAX1099MSGSRQV1$28 = 
        new javax.xml.namespace.QName("", "TAX1099MSGSRQV1");
    private static final javax.xml.namespace.QName TAXW2MSGSRQV1$30 = 
        new javax.xml.namespace.QName("", "TAXW2MSGSRQV1");
    private static final javax.xml.namespace.QName SIGNONMSGSRSV1$32 = 
        new javax.xml.namespace.QName("", "SIGNONMSGSRSV1");
    private static final javax.xml.namespace.QName SIGNUPMSGSRSV1$34 = 
        new javax.xml.namespace.QName("", "SIGNUPMSGSRSV1");
    private static final javax.xml.namespace.QName BANKMSGSRSV1$36 = 
        new javax.xml.namespace.QName("", "BANKMSGSRSV1");
    private static final javax.xml.namespace.QName CREDITCARDMSGSRSV1$38 = 
        new javax.xml.namespace.QName("", "CREDITCARDMSGSRSV1");
    private static final javax.xml.namespace.QName INVSTMTMSGSRSV1$40 = 
        new javax.xml.namespace.QName("", "INVSTMTMSGSRSV1");
    private static final javax.xml.namespace.QName INTERXFERMSGSRSV1$42 = 
        new javax.xml.namespace.QName("", "INTERXFERMSGSRSV1");
    private static final javax.xml.namespace.QName WIREXFERMSGSRSV1$44 = 
        new javax.xml.namespace.QName("", "WIREXFERMSGSRSV1");
    private static final javax.xml.namespace.QName BILLPAYMSGSRSV1$46 = 
        new javax.xml.namespace.QName("", "BILLPAYMSGSRSV1");
    private static final javax.xml.namespace.QName EMAILMSGSRSV1$48 = 
        new javax.xml.namespace.QName("", "EMAILMSGSRSV1");
    private static final javax.xml.namespace.QName SECLISTMSGSRSV1$50 = 
        new javax.xml.namespace.QName("", "SECLISTMSGSRSV1");
    private static final javax.xml.namespace.QName PRESDIRMSGSRSV1$52 = 
        new javax.xml.namespace.QName("", "PRESDIRMSGSRSV1");
    private static final javax.xml.namespace.QName PRESDLVMSGSRSV1$54 = 
        new javax.xml.namespace.QName("", "PRESDLVMSGSRSV1");
    private static final javax.xml.namespace.QName PROFMSGSRSV1$56 = 
        new javax.xml.namespace.QName("", "PROFMSGSRSV1");
    private static final javax.xml.namespace.QName TAX1098MSGSRSV1$58 = 
        new javax.xml.namespace.QName("", "TAX1098MSGSRSV1");
    private static final javax.xml.namespace.QName TAX1099MSGSRSV1$60 = 
        new javax.xml.namespace.QName("", "TAX1099MSGSRSV1");
    private static final javax.xml.namespace.QName TAXW2MSGSRSV1$62 = 
        new javax.xml.namespace.QName("", "TAXW2MSGSRSV1");
    
    
    /**
     * Gets the "SIGNONMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.SignonRequestMessageSetV1 getSIGNONMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignonRequestMessageSetV1)get_store().find_element_user(SIGNONMSGSRQV1$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "SIGNONMSGSRQV1" element
     */
    public boolean isSetSIGNONMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SIGNONMSGSRQV1$0) != 0;
        }
    }
    
    /**
     * Sets the "SIGNONMSGSRQV1" element
     */
    public void setSIGNONMSGSRQV1(net.ofx.types.x2003.x04.SignonRequestMessageSetV1 signonmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignonRequestMessageSetV1)get_store().find_element_user(SIGNONMSGSRQV1$0, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.SignonRequestMessageSetV1)get_store().add_element_user(SIGNONMSGSRQV1$0);
            }
            target.set(signonmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "SIGNONMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.SignonRequestMessageSetV1 addNewSIGNONMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignonRequestMessageSetV1)get_store().add_element_user(SIGNONMSGSRQV1$0);
            return target;
        }
    }
    
    /**
     * Unsets the "SIGNONMSGSRQV1" element
     */
    public void unsetSIGNONMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SIGNONMSGSRQV1$0, 0);
        }
    }
    
    /**
     * Gets the "SIGNUPMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.SignupRequestMessageSetV1 getSIGNUPMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignupRequestMessageSetV1)get_store().find_element_user(SIGNUPMSGSRQV1$2, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "SIGNUPMSGSRQV1" element
     */
    public boolean isSetSIGNUPMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SIGNUPMSGSRQV1$2) != 0;
        }
    }
    
    /**
     * Sets the "SIGNUPMSGSRQV1" element
     */
    public void setSIGNUPMSGSRQV1(net.ofx.types.x2003.x04.SignupRequestMessageSetV1 signupmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignupRequestMessageSetV1)get_store().find_element_user(SIGNUPMSGSRQV1$2, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.SignupRequestMessageSetV1)get_store().add_element_user(SIGNUPMSGSRQV1$2);
            }
            target.set(signupmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "SIGNUPMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.SignupRequestMessageSetV1 addNewSIGNUPMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignupRequestMessageSetV1)get_store().add_element_user(SIGNUPMSGSRQV1$2);
            return target;
        }
    }
    
    /**
     * Unsets the "SIGNUPMSGSRQV1" element
     */
    public void unsetSIGNUPMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SIGNUPMSGSRQV1$2, 0);
        }
    }
    
    /**
     * Gets the "BANKMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.BankRequestMessageSetV1 getBANKMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BankRequestMessageSetV1)get_store().find_element_user(BANKMSGSRQV1$4, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "BANKMSGSRQV1" element
     */
    public boolean isSetBANKMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BANKMSGSRQV1$4) != 0;
        }
    }
    
    /**
     * Sets the "BANKMSGSRQV1" element
     */
    public void setBANKMSGSRQV1(net.ofx.types.x2003.x04.BankRequestMessageSetV1 bankmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BankRequestMessageSetV1)get_store().find_element_user(BANKMSGSRQV1$4, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.BankRequestMessageSetV1)get_store().add_element_user(BANKMSGSRQV1$4);
            }
            target.set(bankmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "BANKMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.BankRequestMessageSetV1 addNewBANKMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BankRequestMessageSetV1)get_store().add_element_user(BANKMSGSRQV1$4);
            return target;
        }
    }
    
    /**
     * Unsets the "BANKMSGSRQV1" element
     */
    public void unsetBANKMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BANKMSGSRQV1$4, 0);
        }
    }
    
    /**
     * Gets the "CREDITCARDMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1 getCREDITCARDMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1)get_store().find_element_user(CREDITCARDMSGSRQV1$6, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "CREDITCARDMSGSRQV1" element
     */
    public boolean isSetCREDITCARDMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CREDITCARDMSGSRQV1$6) != 0;
        }
    }
    
    /**
     * Sets the "CREDITCARDMSGSRQV1" element
     */
    public void setCREDITCARDMSGSRQV1(net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1 creditcardmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1)get_store().find_element_user(CREDITCARDMSGSRQV1$6, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1)get_store().add_element_user(CREDITCARDMSGSRQV1$6);
            }
            target.set(creditcardmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "CREDITCARDMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1 addNewCREDITCARDMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.CreditcardRequestMessageSetV1)get_store().add_element_user(CREDITCARDMSGSRQV1$6);
            return target;
        }
    }
    
    /**
     * Unsets the "CREDITCARDMSGSRQV1" element
     */
    public void unsetCREDITCARDMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CREDITCARDMSGSRQV1$6, 0);
        }
    }
    
    /**
     * Gets the "INVSTMTMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1 getINVSTMTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1)get_store().find_element_user(INVSTMTMSGSRQV1$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "INVSTMTMSGSRQV1" element
     */
    public boolean isSetINVSTMTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INVSTMTMSGSRQV1$8) != 0;
        }
    }
    
    /**
     * Sets the "INVSTMTMSGSRQV1" element
     */
    public void setINVSTMTMSGSRQV1(net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1 invstmtmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1)get_store().find_element_user(INVSTMTMSGSRQV1$8, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1)get_store().add_element_user(INVSTMTMSGSRQV1$8);
            }
            target.set(invstmtmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "INVSTMTMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1 addNewINVSTMTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementRequestMessageSetV1)get_store().add_element_user(INVSTMTMSGSRQV1$8);
            return target;
        }
    }
    
    /**
     * Unsets the "INVSTMTMSGSRQV1" element
     */
    public void unsetINVSTMTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INVSTMTMSGSRQV1$8, 0);
        }
    }
    
    /**
     * Gets the "INTERXFERMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1 getINTERXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1)get_store().find_element_user(INTERXFERMSGSRQV1$10, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "INTERXFERMSGSRQV1" element
     */
    public boolean isSetINTERXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTERXFERMSGSRQV1$10) != 0;
        }
    }
    
    /**
     * Sets the "INTERXFERMSGSRQV1" element
     */
    public void setINTERXFERMSGSRQV1(net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1 interxfermsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1)get_store().find_element_user(INTERXFERMSGSRQV1$10, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1)get_store().add_element_user(INTERXFERMSGSRQV1$10);
            }
            target.set(interxfermsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "INTERXFERMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1 addNewINTERXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InterTransferRequestMessageSetV1)get_store().add_element_user(INTERXFERMSGSRQV1$10);
            return target;
        }
    }
    
    /**
     * Unsets the "INTERXFERMSGSRQV1" element
     */
    public void unsetINTERXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTERXFERMSGSRQV1$10, 0);
        }
    }
    
    /**
     * Gets the "WIREXFERMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1 getWIREXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1)get_store().find_element_user(WIREXFERMSGSRQV1$12, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "WIREXFERMSGSRQV1" element
     */
    public boolean isSetWIREXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WIREXFERMSGSRQV1$12) != 0;
        }
    }
    
    /**
     * Sets the "WIREXFERMSGSRQV1" element
     */
    public void setWIREXFERMSGSRQV1(net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1 wirexfermsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1)get_store().find_element_user(WIREXFERMSGSRQV1$12, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1)get_store().add_element_user(WIREXFERMSGSRQV1$12);
            }
            target.set(wirexfermsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "WIREXFERMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1 addNewWIREXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.WireTransferRequestMessageSetV1)get_store().add_element_user(WIREXFERMSGSRQV1$12);
            return target;
        }
    }
    
    /**
     * Unsets the "WIREXFERMSGSRQV1" element
     */
    public void unsetWIREXFERMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WIREXFERMSGSRQV1$12, 0);
        }
    }
    
    /**
     * Gets the "BILLPAYMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.BillPayRequestMessageSetV1 getBILLPAYMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BillPayRequestMessageSetV1)get_store().find_element_user(BILLPAYMSGSRQV1$14, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "BILLPAYMSGSRQV1" element
     */
    public boolean isSetBILLPAYMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BILLPAYMSGSRQV1$14) != 0;
        }
    }
    
    /**
     * Sets the "BILLPAYMSGSRQV1" element
     */
    public void setBILLPAYMSGSRQV1(net.ofx.types.x2003.x04.BillPayRequestMessageSetV1 billpaymsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BillPayRequestMessageSetV1)get_store().find_element_user(BILLPAYMSGSRQV1$14, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.BillPayRequestMessageSetV1)get_store().add_element_user(BILLPAYMSGSRQV1$14);
            }
            target.set(billpaymsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "BILLPAYMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.BillPayRequestMessageSetV1 addNewBILLPAYMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BillPayRequestMessageSetV1)get_store().add_element_user(BILLPAYMSGSRQV1$14);
            return target;
        }
    }
    
    /**
     * Unsets the "BILLPAYMSGSRQV1" element
     */
    public void unsetBILLPAYMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BILLPAYMSGSRQV1$14, 0);
        }
    }
    
    /**
     * Gets the "EMAILMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.EmailRequestMessageSetV1 getEMAILMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.EmailRequestMessageSetV1)get_store().find_element_user(EMAILMSGSRQV1$16, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "EMAILMSGSRQV1" element
     */
    public boolean isSetEMAILMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EMAILMSGSRQV1$16) != 0;
        }
    }
    
    /**
     * Sets the "EMAILMSGSRQV1" element
     */
    public void setEMAILMSGSRQV1(net.ofx.types.x2003.x04.EmailRequestMessageSetV1 emailmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.EmailRequestMessageSetV1)get_store().find_element_user(EMAILMSGSRQV1$16, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.EmailRequestMessageSetV1)get_store().add_element_user(EMAILMSGSRQV1$16);
            }
            target.set(emailmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "EMAILMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.EmailRequestMessageSetV1 addNewEMAILMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.EmailRequestMessageSetV1)get_store().add_element_user(EMAILMSGSRQV1$16);
            return target;
        }
    }
    
    /**
     * Unsets the "EMAILMSGSRQV1" element
     */
    public void unsetEMAILMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EMAILMSGSRQV1$16, 0);
        }
    }
    
    /**
     * Gets the "SECLISTMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1 getSECLISTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1)get_store().find_element_user(SECLISTMSGSRQV1$18, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "SECLISTMSGSRQV1" element
     */
    public boolean isSetSECLISTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SECLISTMSGSRQV1$18) != 0;
        }
    }
    
    /**
     * Sets the "SECLISTMSGSRQV1" element
     */
    public void setSECLISTMSGSRQV1(net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1 seclistmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1)get_store().find_element_user(SECLISTMSGSRQV1$18, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1)get_store().add_element_user(SECLISTMSGSRQV1$18);
            }
            target.set(seclistmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "SECLISTMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1 addNewSECLISTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SecurityListRequestMessageSetV1)get_store().add_element_user(SECLISTMSGSRQV1$18);
            return target;
        }
    }
    
    /**
     * Unsets the "SECLISTMSGSRQV1" element
     */
    public void unsetSECLISTMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SECLISTMSGSRQV1$18, 0);
        }
    }
    
    /**
     * Gets the "PRESDIRMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1 getPRESDIRMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1)get_store().find_element_user(PRESDIRMSGSRQV1$20, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "PRESDIRMSGSRQV1" element
     */
    public boolean isSetPRESDIRMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRESDIRMSGSRQV1$20) != 0;
        }
    }
    
    /**
     * Sets the "PRESDIRMSGSRQV1" element
     */
    public void setPRESDIRMSGSRQV1(net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1 presdirmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1)get_store().find_element_user(PRESDIRMSGSRQV1$20, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1)get_store().add_element_user(PRESDIRMSGSRQV1$20);
            }
            target.set(presdirmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "PRESDIRMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1 addNewPRESDIRMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirRequestMessageSetV1)get_store().add_element_user(PRESDIRMSGSRQV1$20);
            return target;
        }
    }
    
    /**
     * Unsets the "PRESDIRMSGSRQV1" element
     */
    public void unsetPRESDIRMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRESDIRMSGSRQV1$20, 0);
        }
    }
    
    /**
     * Gets the "PRESDLVMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1 getPRESDLVMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1)get_store().find_element_user(PRESDLVMSGSRQV1$22, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "PRESDLVMSGSRQV1" element
     */
    public boolean isSetPRESDLVMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRESDLVMSGSRQV1$22) != 0;
        }
    }
    
    /**
     * Sets the "PRESDLVMSGSRQV1" element
     */
    public void setPRESDLVMSGSRQV1(net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1 presdlvmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1)get_store().find_element_user(PRESDLVMSGSRQV1$22, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1)get_store().add_element_user(PRESDLVMSGSRQV1$22);
            }
            target.set(presdlvmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "PRESDLVMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1 addNewPRESDLVMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDeliveryRequestMessageSetV1)get_store().add_element_user(PRESDLVMSGSRQV1$22);
            return target;
        }
    }
    
    /**
     * Unsets the "PRESDLVMSGSRQV1" element
     */
    public void unsetPRESDLVMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRESDLVMSGSRQV1$22, 0);
        }
    }
    
    /**
     * Gets the "PROFMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.ProfileRequestMessageSetV1 getPROFMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.ProfileRequestMessageSetV1)get_store().find_element_user(PROFMSGSRQV1$24, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "PROFMSGSRQV1" element
     */
    public boolean isSetPROFMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PROFMSGSRQV1$24) != 0;
        }
    }
    
    /**
     * Sets the "PROFMSGSRQV1" element
     */
    public void setPROFMSGSRQV1(net.ofx.types.x2003.x04.ProfileRequestMessageSetV1 profmsgsrqv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.ProfileRequestMessageSetV1)get_store().find_element_user(PROFMSGSRQV1$24, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.ProfileRequestMessageSetV1)get_store().add_element_user(PROFMSGSRQV1$24);
            }
            target.set(profmsgsrqv1);
        }
    }
    
    /**
     * Appends and returns a new empty "PROFMSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.ProfileRequestMessageSetV1 addNewPROFMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileRequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.ProfileRequestMessageSetV1)get_store().add_element_user(PROFMSGSRQV1$24);
            return target;
        }
    }
    
    /**
     * Unsets the "PROFMSGSRQV1" element
     */
    public void unsetPROFMSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PROFMSGSRQV1$24, 0);
        }
    }
    
    /**
     * Gets the "TAX1098MSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1 getTAX1098MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1)get_store().find_element_user(TAX1098MSGSRQV1$26, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "TAX1098MSGSRQV1" element
     */
    public boolean isSetTAX1098MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAX1098MSGSRQV1$26) != 0;
        }
    }
    
    /**
     * Sets the "TAX1098MSGSRQV1" element
     */
    public void setTAX1098MSGSRQV1(net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1 tax1098MSGSRQV1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1)get_store().find_element_user(TAX1098MSGSRQV1$26, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1)get_store().add_element_user(TAX1098MSGSRQV1$26);
            }
            target.set(tax1098MSGSRQV1);
        }
    }
    
    /**
     * Appends and returns a new empty "TAX1098MSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1 addNewTAX1098MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1098RequestMessageSetV1)get_store().add_element_user(TAX1098MSGSRQV1$26);
            return target;
        }
    }
    
    /**
     * Unsets the "TAX1098MSGSRQV1" element
     */
    public void unsetTAX1098MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAX1098MSGSRQV1$26, 0);
        }
    }
    
    /**
     * Gets the "TAX1099MSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1 getTAX1099MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1)get_store().find_element_user(TAX1099MSGSRQV1$28, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "TAX1099MSGSRQV1" element
     */
    public boolean isSetTAX1099MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAX1099MSGSRQV1$28) != 0;
        }
    }
    
    /**
     * Sets the "TAX1099MSGSRQV1" element
     */
    public void setTAX1099MSGSRQV1(net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1 tax1099MSGSRQV1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1)get_store().find_element_user(TAX1099MSGSRQV1$28, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1)get_store().add_element_user(TAX1099MSGSRQV1$28);
            }
            target.set(tax1099MSGSRQV1);
        }
    }
    
    /**
     * Appends and returns a new empty "TAX1099MSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1 addNewTAX1099MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1099RequestMessageSetV1)get_store().add_element_user(TAX1099MSGSRQV1$28);
            return target;
        }
    }
    
    /**
     * Unsets the "TAX1099MSGSRQV1" element
     */
    public void unsetTAX1099MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAX1099MSGSRQV1$28, 0);
        }
    }
    
    /**
     * Gets the "TAXW2MSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1 getTAXW2MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1)get_store().find_element_user(TAXW2MSGSRQV1$30, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "TAXW2MSGSRQV1" element
     */
    public boolean isSetTAXW2MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAXW2MSGSRQV1$30) != 0;
        }
    }
    
    /**
     * Sets the "TAXW2MSGSRQV1" element
     */
    public void setTAXW2MSGSRQV1(net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1 taxw2MSGSRQV1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1)get_store().find_element_user(TAXW2MSGSRQV1$30, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1)get_store().add_element_user(TAXW2MSGSRQV1$30);
            }
            target.set(taxw2MSGSRQV1);
        }
    }
    
    /**
     * Appends and returns a new empty "TAXW2MSGSRQV1" element
     */
    public net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1 addNewTAXW2MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.TaxW2RequestMessageSetV1)get_store().add_element_user(TAXW2MSGSRQV1$30);
            return target;
        }
    }
    
    /**
     * Unsets the "TAXW2MSGSRQV1" element
     */
    public void unsetTAXW2MSGSRQV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAXW2MSGSRQV1$30, 0);
        }
    }
    
    /**
     * Gets the "SIGNONMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.SignonResponseMessageSetV1 getSIGNONMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignonResponseMessageSetV1)get_store().find_element_user(SIGNONMSGSRSV1$32, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "SIGNONMSGSRSV1" element
     */
    public boolean isSetSIGNONMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SIGNONMSGSRSV1$32) != 0;
        }
    }
    
    /**
     * Sets the "SIGNONMSGSRSV1" element
     */
    public void setSIGNONMSGSRSV1(net.ofx.types.x2003.x04.SignonResponseMessageSetV1 signonmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignonResponseMessageSetV1)get_store().find_element_user(SIGNONMSGSRSV1$32, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.SignonResponseMessageSetV1)get_store().add_element_user(SIGNONMSGSRSV1$32);
            }
            target.set(signonmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "SIGNONMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.SignonResponseMessageSetV1 addNewSIGNONMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignonResponseMessageSetV1)get_store().add_element_user(SIGNONMSGSRSV1$32);
            return target;
        }
    }
    
    /**
     * Unsets the "SIGNONMSGSRSV1" element
     */
    public void unsetSIGNONMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SIGNONMSGSRSV1$32, 0);
        }
    }
    
    /**
     * Gets the "SIGNUPMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.SignupResponseMessageSetV1 getSIGNUPMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignupResponseMessageSetV1)get_store().find_element_user(SIGNUPMSGSRSV1$34, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "SIGNUPMSGSRSV1" element
     */
    public boolean isSetSIGNUPMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SIGNUPMSGSRSV1$34) != 0;
        }
    }
    
    /**
     * Sets the "SIGNUPMSGSRSV1" element
     */
    public void setSIGNUPMSGSRSV1(net.ofx.types.x2003.x04.SignupResponseMessageSetV1 signupmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignupResponseMessageSetV1)get_store().find_element_user(SIGNUPMSGSRSV1$34, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.SignupResponseMessageSetV1)get_store().add_element_user(SIGNUPMSGSRSV1$34);
            }
            target.set(signupmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "SIGNUPMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.SignupResponseMessageSetV1 addNewSIGNUPMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SignupResponseMessageSetV1)get_store().add_element_user(SIGNUPMSGSRSV1$34);
            return target;
        }
    }
    
    /**
     * Unsets the "SIGNUPMSGSRSV1" element
     */
    public void unsetSIGNUPMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SIGNUPMSGSRSV1$34, 0);
        }
    }
    
    /**
     * Gets the "BANKMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.BankResponseMessageSetV1 getBANKMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BankResponseMessageSetV1)get_store().find_element_user(BANKMSGSRSV1$36, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "BANKMSGSRSV1" element
     */
    public boolean isSetBANKMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BANKMSGSRSV1$36) != 0;
        }
    }
    
    /**
     * Sets the "BANKMSGSRSV1" element
     */
    public void setBANKMSGSRSV1(net.ofx.types.x2003.x04.BankResponseMessageSetV1 bankmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BankResponseMessageSetV1)get_store().find_element_user(BANKMSGSRSV1$36, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.BankResponseMessageSetV1)get_store().add_element_user(BANKMSGSRSV1$36);
            }
            target.set(bankmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "BANKMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.BankResponseMessageSetV1 addNewBANKMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BankResponseMessageSetV1)get_store().add_element_user(BANKMSGSRSV1$36);
            return target;
        }
    }
    
    /**
     * Unsets the "BANKMSGSRSV1" element
     */
    public void unsetBANKMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BANKMSGSRSV1$36, 0);
        }
    }
    
    /**
     * Gets the "CREDITCARDMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1 getCREDITCARDMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1)get_store().find_element_user(CREDITCARDMSGSRSV1$38, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "CREDITCARDMSGSRSV1" element
     */
    public boolean isSetCREDITCARDMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CREDITCARDMSGSRSV1$38) != 0;
        }
    }
    
    /**
     * Sets the "CREDITCARDMSGSRSV1" element
     */
    public void setCREDITCARDMSGSRSV1(net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1 creditcardmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1)get_store().find_element_user(CREDITCARDMSGSRSV1$38, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1)get_store().add_element_user(CREDITCARDMSGSRSV1$38);
            }
            target.set(creditcardmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "CREDITCARDMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1 addNewCREDITCARDMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.CreditcardResponseMessageSetV1)get_store().add_element_user(CREDITCARDMSGSRSV1$38);
            return target;
        }
    }
    
    /**
     * Unsets the "CREDITCARDMSGSRSV1" element
     */
    public void unsetCREDITCARDMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CREDITCARDMSGSRSV1$38, 0);
        }
    }
    
    /**
     * Gets the "INVSTMTMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1 getINVSTMTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1)get_store().find_element_user(INVSTMTMSGSRSV1$40, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "INVSTMTMSGSRSV1" element
     */
    public boolean isSetINVSTMTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INVSTMTMSGSRSV1$40) != 0;
        }
    }
    
    /**
     * Sets the "INVSTMTMSGSRSV1" element
     */
    public void setINVSTMTMSGSRSV1(net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1 invstmtmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1)get_store().find_element_user(INVSTMTMSGSRSV1$40, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1)get_store().add_element_user(INVSTMTMSGSRSV1$40);
            }
            target.set(invstmtmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "INVSTMTMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1 addNewINVSTMTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementResponseMessageSetV1)get_store().add_element_user(INVSTMTMSGSRSV1$40);
            return target;
        }
    }
    
    /**
     * Unsets the "INVSTMTMSGSRSV1" element
     */
    public void unsetINVSTMTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INVSTMTMSGSRSV1$40, 0);
        }
    }
    
    /**
     * Gets the "INTERXFERMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1 getINTERXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1)get_store().find_element_user(INTERXFERMSGSRSV1$42, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "INTERXFERMSGSRSV1" element
     */
    public boolean isSetINTERXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTERXFERMSGSRSV1$42) != 0;
        }
    }
    
    /**
     * Sets the "INTERXFERMSGSRSV1" element
     */
    public void setINTERXFERMSGSRSV1(net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1 interxfermsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1)get_store().find_element_user(INTERXFERMSGSRSV1$42, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1)get_store().add_element_user(INTERXFERMSGSRSV1$42);
            }
            target.set(interxfermsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "INTERXFERMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1 addNewINTERXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.InterTransferResponseMessageSetV1)get_store().add_element_user(INTERXFERMSGSRSV1$42);
            return target;
        }
    }
    
    /**
     * Unsets the "INTERXFERMSGSRSV1" element
     */
    public void unsetINTERXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTERXFERMSGSRSV1$42, 0);
        }
    }
    
    /**
     * Gets the "WIREXFERMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1 getWIREXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1)get_store().find_element_user(WIREXFERMSGSRSV1$44, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "WIREXFERMSGSRSV1" element
     */
    public boolean isSetWIREXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WIREXFERMSGSRSV1$44) != 0;
        }
    }
    
    /**
     * Sets the "WIREXFERMSGSRSV1" element
     */
    public void setWIREXFERMSGSRSV1(net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1 wirexfermsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1)get_store().find_element_user(WIREXFERMSGSRSV1$44, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1)get_store().add_element_user(WIREXFERMSGSRSV1$44);
            }
            target.set(wirexfermsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "WIREXFERMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1 addNewWIREXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.WireTransferResponseMessageSetV1)get_store().add_element_user(WIREXFERMSGSRSV1$44);
            return target;
        }
    }
    
    /**
     * Unsets the "WIREXFERMSGSRSV1" element
     */
    public void unsetWIREXFERMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WIREXFERMSGSRSV1$44, 0);
        }
    }
    
    /**
     * Gets the "BILLPAYMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.BillPayResponseMessageSetV1 getBILLPAYMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BillPayResponseMessageSetV1)get_store().find_element_user(BILLPAYMSGSRSV1$46, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "BILLPAYMSGSRSV1" element
     */
    public boolean isSetBILLPAYMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BILLPAYMSGSRSV1$46) != 0;
        }
    }
    
    /**
     * Sets the "BILLPAYMSGSRSV1" element
     */
    public void setBILLPAYMSGSRSV1(net.ofx.types.x2003.x04.BillPayResponseMessageSetV1 billpaymsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BillPayResponseMessageSetV1)get_store().find_element_user(BILLPAYMSGSRSV1$46, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.BillPayResponseMessageSetV1)get_store().add_element_user(BILLPAYMSGSRSV1$46);
            }
            target.set(billpaymsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "BILLPAYMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.BillPayResponseMessageSetV1 addNewBILLPAYMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.BillPayResponseMessageSetV1)get_store().add_element_user(BILLPAYMSGSRSV1$46);
            return target;
        }
    }
    
    /**
     * Unsets the "BILLPAYMSGSRSV1" element
     */
    public void unsetBILLPAYMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BILLPAYMSGSRSV1$46, 0);
        }
    }
    
    /**
     * Gets the "EMAILMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.EmailResponseMessageSetV1 getEMAILMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.EmailResponseMessageSetV1)get_store().find_element_user(EMAILMSGSRSV1$48, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "EMAILMSGSRSV1" element
     */
    public boolean isSetEMAILMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EMAILMSGSRSV1$48) != 0;
        }
    }
    
    /**
     * Sets the "EMAILMSGSRSV1" element
     */
    public void setEMAILMSGSRSV1(net.ofx.types.x2003.x04.EmailResponseMessageSetV1 emailmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.EmailResponseMessageSetV1)get_store().find_element_user(EMAILMSGSRSV1$48, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.EmailResponseMessageSetV1)get_store().add_element_user(EMAILMSGSRSV1$48);
            }
            target.set(emailmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "EMAILMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.EmailResponseMessageSetV1 addNewEMAILMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.EmailResponseMessageSetV1)get_store().add_element_user(EMAILMSGSRSV1$48);
            return target;
        }
    }
    
    /**
     * Unsets the "EMAILMSGSRSV1" element
     */
    public void unsetEMAILMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EMAILMSGSRSV1$48, 0);
        }
    }
    
    /**
     * Gets the "SECLISTMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1 getSECLISTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1)get_store().find_element_user(SECLISTMSGSRSV1$50, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "SECLISTMSGSRSV1" element
     */
    public boolean isSetSECLISTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SECLISTMSGSRSV1$50) != 0;
        }
    }
    
    /**
     * Sets the "SECLISTMSGSRSV1" element
     */
    public void setSECLISTMSGSRSV1(net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1 seclistmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1)get_store().find_element_user(SECLISTMSGSRSV1$50, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1)get_store().add_element_user(SECLISTMSGSRSV1$50);
            }
            target.set(seclistmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "SECLISTMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1 addNewSECLISTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.SecurityListResponseMessageSetV1)get_store().add_element_user(SECLISTMSGSRSV1$50);
            return target;
        }
    }
    
    /**
     * Unsets the "SECLISTMSGSRSV1" element
     */
    public void unsetSECLISTMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SECLISTMSGSRSV1$50, 0);
        }
    }
    
    /**
     * Gets the "PRESDIRMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1 getPRESDIRMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1)get_store().find_element_user(PRESDIRMSGSRSV1$52, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "PRESDIRMSGSRSV1" element
     */
    public boolean isSetPRESDIRMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRESDIRMSGSRSV1$52) != 0;
        }
    }
    
    /**
     * Sets the "PRESDIRMSGSRSV1" element
     */
    public void setPRESDIRMSGSRSV1(net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1 presdirmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1)get_store().find_element_user(PRESDIRMSGSRSV1$52, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1)get_store().add_element_user(PRESDIRMSGSRSV1$52);
            }
            target.set(presdirmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "PRESDIRMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1 addNewPRESDIRMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirResponseMessageSetV1)get_store().add_element_user(PRESDIRMSGSRSV1$52);
            return target;
        }
    }
    
    /**
     * Unsets the "PRESDIRMSGSRSV1" element
     */
    public void unsetPRESDIRMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRESDIRMSGSRSV1$52, 0);
        }
    }
    
    /**
     * Gets the "PRESDLVMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1 getPRESDLVMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1)get_store().find_element_user(PRESDLVMSGSRSV1$54, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "PRESDLVMSGSRSV1" element
     */
    public boolean isSetPRESDLVMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRESDLVMSGSRSV1$54) != 0;
        }
    }
    
    /**
     * Sets the "PRESDLVMSGSRSV1" element
     */
    public void setPRESDLVMSGSRSV1(net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1 presdlvmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1)get_store().find_element_user(PRESDLVMSGSRSV1$54, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1)get_store().add_element_user(PRESDLVMSGSRSV1$54);
            }
            target.set(presdlvmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "PRESDLVMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1 addNewPRESDLVMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDeliveryResponseMessageSetV1)get_store().add_element_user(PRESDLVMSGSRSV1$54);
            return target;
        }
    }
    
    /**
     * Unsets the "PRESDLVMSGSRSV1" element
     */
    public void unsetPRESDLVMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRESDLVMSGSRSV1$54, 0);
        }
    }
    
    /**
     * Gets the "PROFMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.ProfileResponseMessageSetV1 getPROFMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.ProfileResponseMessageSetV1)get_store().find_element_user(PROFMSGSRSV1$56, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "PROFMSGSRSV1" element
     */
    public boolean isSetPROFMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PROFMSGSRSV1$56) != 0;
        }
    }
    
    /**
     * Sets the "PROFMSGSRSV1" element
     */
    public void setPROFMSGSRSV1(net.ofx.types.x2003.x04.ProfileResponseMessageSetV1 profmsgsrsv1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.ProfileResponseMessageSetV1)get_store().find_element_user(PROFMSGSRSV1$56, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.ProfileResponseMessageSetV1)get_store().add_element_user(PROFMSGSRSV1$56);
            }
            target.set(profmsgsrsv1);
        }
    }
    
    /**
     * Appends and returns a new empty "PROFMSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.ProfileResponseMessageSetV1 addNewPROFMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.ProfileResponseMessageSetV1)get_store().add_element_user(PROFMSGSRSV1$56);
            return target;
        }
    }
    
    /**
     * Unsets the "PROFMSGSRSV1" element
     */
    public void unsetPROFMSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PROFMSGSRSV1$56, 0);
        }
    }
    
    /**
     * Gets the "TAX1098MSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1 getTAX1098MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1)get_store().find_element_user(TAX1098MSGSRSV1$58, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "TAX1098MSGSRSV1" element
     */
    public boolean isSetTAX1098MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAX1098MSGSRSV1$58) != 0;
        }
    }
    
    /**
     * Sets the "TAX1098MSGSRSV1" element
     */
    public void setTAX1098MSGSRSV1(net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1 tax1098MSGSRSV1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1)get_store().find_element_user(TAX1098MSGSRSV1$58, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1)get_store().add_element_user(TAX1098MSGSRSV1$58);
            }
            target.set(tax1098MSGSRSV1);
        }
    }
    
    /**
     * Appends and returns a new empty "TAX1098MSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1 addNewTAX1098MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1098ResponseMessageSetV1)get_store().add_element_user(TAX1098MSGSRSV1$58);
            return target;
        }
    }
    
    /**
     * Unsets the "TAX1098MSGSRSV1" element
     */
    public void unsetTAX1098MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAX1098MSGSRSV1$58, 0);
        }
    }
    
    /**
     * Gets the "TAX1099MSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1 getTAX1099MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1)get_store().find_element_user(TAX1099MSGSRSV1$60, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "TAX1099MSGSRSV1" element
     */
    public boolean isSetTAX1099MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAX1099MSGSRSV1$60) != 0;
        }
    }
    
    /**
     * Sets the "TAX1099MSGSRSV1" element
     */
    public void setTAX1099MSGSRSV1(net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1 tax1099MSGSRSV1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1)get_store().find_element_user(TAX1099MSGSRSV1$60, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1)get_store().add_element_user(TAX1099MSGSRSV1$60);
            }
            target.set(tax1099MSGSRSV1);
        }
    }
    
    /**
     * Appends and returns a new empty "TAX1099MSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1 addNewTAX1099MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.Tax1099ResponseMessageSetV1)get_store().add_element_user(TAX1099MSGSRSV1$60);
            return target;
        }
    }
    
    /**
     * Unsets the "TAX1099MSGSRSV1" element
     */
    public void unsetTAX1099MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAX1099MSGSRSV1$60, 0);
        }
    }
    
    /**
     * Gets the "TAXW2MSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1 getTAXW2MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1)get_store().find_element_user(TAXW2MSGSRSV1$62, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "TAXW2MSGSRSV1" element
     */
    public boolean isSetTAXW2MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAXW2MSGSRSV1$62) != 0;
        }
    }
    
    /**
     * Sets the "TAXW2MSGSRSV1" element
     */
    public void setTAXW2MSGSRSV1(net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1 taxw2MSGSRSV1)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1)get_store().find_element_user(TAXW2MSGSRSV1$62, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1)get_store().add_element_user(TAXW2MSGSRSV1$62);
            }
            target.set(taxw2MSGSRSV1);
        }
    }
    
    /**
     * Appends and returns a new empty "TAXW2MSGSRSV1" element
     */
    public net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1 addNewTAXW2MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1 target = null;
            target = (net.ofx.types.x2003.x04.TaxW2ResponseMessageSetV1)get_store().add_element_user(TAXW2MSGSRSV1$62);
            return target;
        }
    }
    
    /**
     * Unsets the "TAXW2MSGSRSV1" element
     */
    public void unsetTAXW2MSGSRSV1()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAXW2MSGSRSV1$62, 0);
        }
    }
}
